home *** CD-ROM | disk | FTP | other *** search
/ Popular Request / By Popular Request (Arsenal Computer)(SysOptics Distribution System).ISO / amiga2 / gas-2_2.lha / gas-2.2 / as.info-3 (.txt) < prev    next >
GNU Info File  |  1994-03-17  |  51KB  |  1,094 lines
  1. This is Info file as.info, produced by Makeinfo-1.55 from the input
  2. file ./as.texinfo.
  3. START-INFO-DIR-ENTRY
  4. * As::                          The GNU assembler.
  5. END-INFO-DIR-ENTRY
  6.    This file documents the GNU Assembler "as".
  7.    Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc.
  8.    Permission is granted to make and distribute verbatim copies of this
  9. manual provided the copyright notice and this permission notice are
  10. preserved on all copies.
  11.    Permission is granted to copy and distribute modified versions of
  12. this manual under the conditions for verbatim copying, provided also
  13. that the section entitled "GNU General Public License" is included
  14. exactly as in the original, and provided that the entire resulting
  15. derived work is distributed under the terms of a permission notice
  16. identical to this one.
  17.    Permission is granted to copy and distribute translations of this
  18. manual into another language, under the above conditions for modified
  19. versions, except that the section entitled "GNU General Public License"
  20. may be included in a translation approved by the Free Software
  21. Foundation instead of in the original English.
  22. File: as.info,  Node: AMD29K-Regs,  Prev: AMD29K-Chars,  Up: AMD29K Syntax
  23. Register Names
  24. ..............
  25.    General-purpose registers are represented by predefined symbols of
  26. the form `GRNNN' (for global registers) or `LRNNN' (for local
  27. registers), where NNN represents a number between `0' and `127',
  28. written with no leading zeros.  The leading letters may be in either
  29. upper or lower case; for example, `gr13' and `LR7' are both valid
  30. register names.
  31.    You may also refer to general-purpose registers by specifying the
  32. register number as the result of an expression (prefixed with `%%' to
  33. flag the expression as a register number):
  34.      %%EXPRESSION
  35. --where EXPRESSION must be an absolute expression evaluating to a
  36. number between `0' and `255'.  The range [0, 127] refers to global
  37. registers, and the range [128, 255] to local registers.
  38.    In addition, `as' understands the following protected
  39. special-purpose register names for the AMD 29K family:
  40.        vab    chd    pc0
  41.        ops    chc    pc1
  42.        cps    rbp    pc2
  43.        cfg    tmc    mmu
  44.        cha    tmr    lru
  45.    These unprotected special-purpose register names are also recognized:
  46.        ipc    alu    fpe
  47.        ipa    bp     inte
  48.        ipb    fc     fps
  49.        q      cr     exop
  50. File: as.info,  Node: AMD29K Floating Point,  Next: AMD29K Directives,  Prev: AMD29K Syntax,  Up: AMD29K-Dependent
  51. Floating Point
  52. --------------
  53.    The AMD 29K family uses IEEE floating-point numbers.
  54. File: as.info,  Node: AMD29K Directives,  Next: AMD29K Opcodes,  Prev: AMD29K Floating Point,  Up: AMD29K-Dependent
  55. AMD 29K Machine Directives
  56. --------------------------
  57. `.block SIZE , FILL'
  58.      This directive emits SIZE bytes, each of value FILL.  Both SIZE
  59.      and FILL are absolute expressions.  If the comma and FILL are
  60.      omitted, FILL is assumed to be zero.
  61.      In other versions of the GNU assembler, this directive is called
  62.      `.space'.
  63. `.cputype'
  64.      This directive is ignored; it is accepted for compatibility with
  65.      other AMD 29K assemblers.
  66. `.file'
  67.      This directive is ignored; it is accepted for compatibility with
  68.      other AMD 29K assemblers.
  69.           *Warning:* in other versions of the GNU assembler, `.file' is
  70.           used for the directive called `.app-file' in the AMD 29K
  71.           support.
  72. `.line'
  73.      This directive is ignored; it is accepted for compatibility with
  74.      other AMD 29K assemblers.
  75. `.sect'
  76.      This directive is ignored; it is accepted for compatibility with
  77.      other AMD 29K assemblers.
  78. `.use SECTION NAME'
  79.      Establishes the section and subsection for the following code;
  80.      SECTION NAME may be one of `.text', `.data', `.data1', or `.lit'.
  81.      With one of the first three SECTION NAME options, `.use' is
  82.      equivalent to the machine directive SECTION NAME; the remaining
  83.      case, `.use .lit', is the same as `.data 200'.
  84. File: as.info,  Node: AMD29K Opcodes,  Prev: AMD29K Directives,  Up: AMD29K-Dependent
  85. Opcodes
  86. -------
  87.    `as' implements all the standard AMD 29K opcodes.  No additional
  88. pseudo-instructions are needed on this family.
  89.    For information on the 29K machine instruction set, see `Am29000
  90. User's Manual', Advanced Micro Devices, Inc.
  91. File: as.info,  Node: H8/300-Dependent,  Next: H8/500-Dependent,  Prev: AMD29K-Dependent,  Up: Machine Dependencies
  92. H8/300 Dependent Features
  93. =========================
  94. * Menu:
  95. * H8/300 Options::              Options
  96. * H8/300 Syntax::               Syntax
  97. * H8/300 Floating Point::       Floating Point
  98. * H8/300 Directives::           H8/300 Machine Directives
  99. * H8/300 Opcodes::              Opcodes
  100. File: as.info,  Node: H8/300 Options,  Next: H8/300 Syntax,  Up: H8/300-Dependent
  101. Options
  102. -------
  103.    `as' has no additional command-line options for the Hitachi H8/300
  104. family.
  105. File: as.info,  Node: H8/300 Syntax,  Next: H8/300 Floating Point,  Prev: H8/300 Options,  Up: H8/300-Dependent
  106. Syntax
  107. ------
  108. * Menu:
  109. * H8/300-Chars::                Special Characters
  110. * H8/300-Regs::                 Register Names
  111. * H8/300-Addressing::           Addressing Modes
  112. File: as.info,  Node: H8/300-Chars,  Next: H8/300-Regs,  Up: H8/300 Syntax
  113. Special Characters
  114. ..................
  115.    `;' is the line comment character.
  116.    `$' can be used instead of a newline to separate statements.
  117. Therefore *you may not use `$' in symbol names* on the H8/300.
  118. File: as.info,  Node: H8/300-Regs,  Next: H8/300-Addressing,  Prev: H8/300-Chars,  Up: H8/300 Syntax
  119. Register Names
  120. ..............
  121.    You can use predefined symbols of the form `rNh' and `rNl' to refer
  122. to the H8/300 registers as sixteen 8-bit general-purpose registers.  N
  123. is a digit from `0' to `7'); for instance, both `r0h' and `r7l' are
  124. valid register names.
  125.    You can also use the eight predefined symbols `rN' to refer to the
  126. H8/300 registers as 16-bit registers (you must use this form for
  127. addressing).
  128.    On the H8/300H, you can also use the eight predefined symbols `erN'
  129. (`er0' ... `er7') to refer to the 32-bit general purpose registers.
  130.    The two control registers are called `pc' (program counter; a 16-bit
  131. register, except on the H8/300H where it is 24 bits) and `ccr'
  132. (condition code register; an 8-bit register).  `r7' is used as the
  133. stack pointer, and can also be called `sp'.
  134. File: as.info,  Node: H8/300-Addressing,  Prev: H8/300-Regs,  Up: H8/300 Syntax
  135. Addressing Modes
  136. ................
  137.    as understands the following addressing modes for the H8/300:
  138.      Register direct
  139. `@rN'
  140.      Register indirect
  141. `@(D, rN)'
  142. `@(D:16, rN)'
  143. `@(D:24, rN)'
  144.      Register indirect: 16-bit or 24-bit displacement D from register
  145.      N.  (24-bit displacements are only meaningful on the H8/300H.)
  146. `@rN+'
  147.      Register indirect with post-increment
  148. `@-rN'
  149.      Register indirect with pre-decrement
  150. ``@'AA'
  151. ``@'AA:8'
  152. ``@'AA:16'
  153. ``@'AA:24'
  154.      Absolute address `aa'.  (The address size `:24' only makes sense
  155.      on the H8/300H.)
  156. `#XX'
  157. `#XX:8'
  158. `#XX:16'
  159. `#XX:32'
  160.      Immediate data XX.  You may specify the `:8', `:16', or `:32' for
  161.      clarity, if you wish; but `as' neither requires this nor uses
  162.      it--the data size required is taken from context.
  163. ``@'`@'AA'
  164. ``@'`@'AA:8'
  165.      Memory indirect.  You may specify the `:8' for clarity, if you
  166.      wish; but `as' neither requires this nor uses it.
  167. File: as.info,  Node: H8/300 Floating Point,  Next: H8/300 Directives,  Prev: H8/300 Syntax,  Up: H8/300-Dependent
  168. Floating Point
  169. --------------
  170.    The H8/300 family has no hardware floating point, but the `.float'
  171. directive generates IEEE floating-point numbers for compatibility with
  172. other development tools.
  173. File: as.info,  Node: H8/300 Directives,  Next: H8/300 Opcodes,  Prev: H8/300 Floating Point,  Up: H8/300-Dependent
  174. H8/300 Machine Directives
  175. -------------------------
  176.    `as' has only one machine-dependent directive for the H8/300:
  177. `.h300h'
  178.      Recognize and emit additional instructions for the H8/300H
  179.      variant, and also make `.int' emit 32-bit numbers rather than the
  180.      usual (16-bit) for the H8/300 family.
  181.    On the H8/300 family (including the H8/300H) `.word' directives
  182. generate 16-bit numbers.
  183. File: as.info,  Node: H8/300 Opcodes,  Prev: H8/300 Directives,  Up: H8/300-Dependent
  184. Opcodes
  185. -------
  186.    For detailed information on the H8/300 machine instruction set, see
  187. `H8/300 Series Programming Manual' (Hitachi ADE-602-025).  For
  188. information specific to the H8/300H, see `H8/300H Series Programming
  189. Manual' (Hitachi).
  190.    `as' implements all the standard H8/300 opcodes.  No additional
  191. pseudo-instructions are needed on this family.
  192.    The following table summarizes the H8/300 opcodes, and their
  193. arguments.  Entries marked `*' are opcodes used only on the H8/300H.
  194.               Legend:
  195.                  Rs   source register
  196.                  Rd   destination register
  197.                  abs  absolute address
  198.                  imm  immediate data
  199.               disp:N  N-bit displacement from a register
  200.              pcrel:N  N-bit displacement relative to program counter
  201.      
  202.         add.b #imm,rd              *  andc #imm,ccr
  203.         add.b rs,rd                   band #imm,rd
  204.         add.w rs,rd                   band #imm,@rd
  205.      *  add.w #imm,rd                 band #imm,@abs:8
  206.      *  add.l rs,rd                   bra  pcrel:8
  207.      *  add.l #imm,rd              *  bra  pcrel:16
  208.         adds #imm,rd                  bt   pcrel:8
  209.         addx #imm,rd               *  bt   pcrel:16
  210.         addx rs,rd                    brn  pcrel:8
  211.         and.b #imm,rd              *  brn  pcrel:16
  212.         and.b rs,rd                   bf   pcrel:8
  213.      *  and.w rs,rd                *  bf   pcrel:16
  214.      *  and.w #imm,rd                 bhi  pcrel:8
  215.      *  and.l #imm,rd              *  bhi  pcrel:16
  216.      *  and.l rs,rd                   bls  pcrel:8
  217.      
  218.      *  bls  pcrel:16                 bld  #imm,rd
  219.         bcc  pcrel:8                  bld  #imm,@rd
  220.      *  bcc  pcrel:16                 bld  #imm,@abs:8
  221.         bhs  pcrel:8                  bnot #imm,rd
  222.      *  bhs  pcrel:16                 bnot #imm,@rd
  223.         bcs  pcrel:8                  bnot #imm,@abs:8
  224.      *  bcs  pcrel:16                 bnot rs,rd
  225.         blo  pcrel:8                  bnot rs,@rd
  226.      *  blo  pcrel:16                 bnot rs,@abs:8
  227.         bne  pcrel:8                  bor  #imm,rd
  228.      *  bne  pcrel:16                 bor  #imm,@rd
  229.         beq  pcrel:8                  bor  #imm,@abs:8
  230.      *  beq  pcrel:16                 bset #imm,rd
  231.         bvc  pcrel:8                  bset #imm,@rd
  232.      *  bvc  pcrel:16                 bset #imm,@abs:8
  233.         bvs  pcrel:8                  bset rs,rd
  234.      *  bvs  pcrel:16                 bset rs,@rd
  235.         bpl  pcrel:8                  bset rs,@abs:8
  236.      *  bpl  pcrel:16                 bsr  pcrel:8
  237.         bmi  pcrel:8                  bsr  pcrel:16
  238.      *  bmi  pcrel:16                 bst  #imm,rd
  239.         bge  pcrel:8                  bst  #imm,@rd
  240.      *  bge  pcrel:16                 bst  #imm,@abs:8
  241.         blt  pcrel:8                  btst #imm,rd
  242.      *  blt  pcrel:16                 btst #imm,@rd
  243.         bgt  pcrel:8                  btst #imm,@abs:8
  244.      *  bgt  pcrel:16                 btst rs,rd
  245.         ble  pcrel:8                  btst rs,@rd
  246.      *  ble  pcrel:16                 btst rs,@abs:8
  247.         bclr #imm,rd                  bxor #imm,rd
  248.         bclr #imm,@rd                 bxor #imm,@rd
  249.         bclr #imm,@abs:8              bxor #imm,@abs:8
  250.         bclr rs,rd                    cmp.b #imm,rd
  251.         bclr rs,@rd                   cmp.b rs,rd
  252.         bclr rs,@abs:8                cmp.w rs,rd
  253.         biand #imm,rd                 cmp.w rs,rd
  254.         biand #imm,@rd             *  cmp.w #imm,rd
  255.         biand #imm,@abs:8          *  cmp.l #imm,rd
  256.         bild #imm,rd               *  cmp.l rs,rd
  257.         bild #imm,@rd                 daa  rs
  258.         bild #imm,@abs:8              das  rs
  259.         bior #imm,rd                  dec.b rs
  260.         bior #imm,@rd              *  dec.w #imm,rd
  261.         bior #imm,@abs:8           *  dec.l #imm,rd
  262.         bist #imm,rd                  divxu.b rs,rd
  263.         bist #imm,@rd              *  divxu.w rs,rd
  264.         bist #imm,@abs:8           *  divxs.b rs,rd
  265.         bixor #imm,rd              *  divxs.w rs,rd
  266.         bixor #imm,@rd                eepmov
  267.         bixor #imm,@abs:8          *  eepmovw
  268.      
  269.      *  exts.w rd                     mov.w rs,@abs:16
  270.      *  exts.l rd                  *  mov.l #imm,rd
  271.      *  extu.w rd                  *  mov.l rs,rd
  272.      *  extu.l rd                  *  mov.l @rs,rd
  273.         inc  rs                    *  mov.l @(disp:16,rs),rd
  274.      *  inc.w #imm,rd              *  mov.l @(disp:24,rs),rd
  275.      *  inc.l #imm,rd              *  mov.l @rs+,rd
  276.         jmp  @rs                   *  mov.l @abs:16,rd
  277.         jmp  abs                   *  mov.l @abs:24,rd
  278.         jmp  @@abs:8               *  mov.l rs,@rd
  279.         jsr  @rs                   *  mov.l rs,@(disp:16,rd)
  280.         jsr  abs                   *  mov.l rs,@(disp:24,rd)
  281.         jsr  @@abs:8               *  mov.l rs,@-rd
  282.         ldc  #imm,ccr              *  mov.l rs,@abs:16
  283.         ldc  rs,ccr                *  mov.l rs,@abs:24
  284.      *  ldc  @abs:16,ccr              movfpe @abs:16,rd
  285.      *  ldc  @abs:24,ccr              movtpe rs,@abs:16
  286.      *  ldc  @(disp:16,rs),ccr        mulxu.b rs,rd
  287.      *  ldc  @(disp:24,rs),ccr     *  mulxu.w rs,rd
  288.      *  ldc  @rs+,ccr              *  mulxs.b rs,rd
  289.      *  ldc  @rs,ccr               *  mulxs.w rs,rd
  290.      *  mov.b @(disp:24,rs),rd        neg.b rs
  291.      *  mov.b rs,@(disp:24,rd)     *  neg.w rs
  292.         mov.b @abs:16,rd           *  neg.l rs
  293.         mov.b rs,rd                   nop
  294.         mov.b @abs:8,rd               not.b rs
  295.         mov.b rs,@abs:8            *  not.w rs
  296.         mov.b rs,rd                *  not.l rs
  297.         mov.b #imm,rd                 or.b #imm,rd
  298.         mov.b @rs,rd                  or.b rs,rd
  299.         mov.b @(disp:16,rs),rd     *  or.w #imm,rd
  300.         mov.b @rs+,rd              *  or.w rs,rd
  301.         mov.b @abs:8,rd            *  or.l #imm,rd
  302.         mov.b rs,@rd               *  or.l rs,rd
  303.         mov.b rs,@(disp:16,rd)        orc  #imm,ccr
  304.         mov.b rs,@-rd                 pop.w rs
  305.         mov.b rs,@abs:8            *  pop.l rs
  306.         mov.w rs,@rd                  push.w rs
  307.      *  mov.w @(disp:24,rs),rd     *  push.l rs
  308.      *  mov.w rs,@(disp:24,rd)        rotl.b rs
  309.      *  mov.w @abs:24,rd           *  rotl.w rs
  310.      *  mov.w rs,@abs:24           *  rotl.l rs
  311.         mov.w rs,rd                   rotr.b rs
  312.         mov.w #imm,rd              *  rotr.w rs
  313.         mov.w @rs,rd               *  rotr.l rs
  314.         mov.w @(disp:16,rs),rd        rotxl.b rs
  315.         mov.w @rs+,rd              *  rotxl.w rs
  316.         mov.w @abs:16,rd           *  rotxl.l rs
  317.         mov.w rs,@(disp:16,rd)        rotxr.b rs
  318.         mov.w rs,@-rd              *  rotxr.w rs
  319.      
  320.      *  rotxr.l rs                 *  stc  ccr,@(disp:24,rd)
  321.         bpt                        *  stc  ccr,@-rd
  322.         rte                        *  stc  ccr,@abs:16
  323.         rts                        *  stc  ccr,@abs:24
  324.         shal.b rs                     sub.b rs,rd
  325.      *  shal.w rs                     sub.w rs,rd
  326.      *  shal.l rs                  *  sub.w #imm,rd
  327.         shar.b rs                  *  sub.l rs,rd
  328.      *  shar.w rs                  *  sub.l #imm,rd
  329.      *  shar.l rs                     subs #imm,rd
  330.         shll.b rs                     subx #imm,rd
  331.      *  shll.w rs                     subx rs,rd
  332.      *  shll.l rs                  *  trapa #imm
  333.         shlr.b rs                     xor  #imm,rd
  334.      *  shlr.w rs                     xor  rs,rd
  335.      *  shlr.l rs                  *  xor.w #imm,rd
  336.         sleep                      *  xor.w rs,rd
  337.         stc  ccr,rd                *  xor.l #imm,rd
  338.      *  stc  ccr,@rs               *  xor.l rs,rd
  339.      *  stc  ccr,@(disp:16,rd)        xorc #imm,ccr
  340.    Four H8/300 instructions (`add', `cmp', `mov', `sub') are defined
  341. with variants using the suffixes `.b', `.w', and `.l' to specify the
  342. size of a memory operand.  `as' supports these suffixes, but does not
  343. require them; since one of the operands is always a register, `as' can
  344. deduce the correct size.
  345.    For example, since `r0' refers to a 16-bit register,
  346.      mov    r0,@foo
  347. is equivalent to
  348.      mov.w  r0,@foo
  349.    If you use the size suffixes, `as' issues a warning when the suffix
  350. and the register size do not match.
  351. File: as.info,  Node: H8/500-Dependent,  Next: SH-Dependent,  Prev: H8/300-Dependent,  Up: Machine Dependencies
  352. H8/500 Dependent Features
  353. =========================
  354. * Menu:
  355. * H8/500 Options::              Options
  356. * H8/500 Syntax::               Syntax
  357. * H8/500 Floating Point::       Floating Point
  358. * H8/500 Directives::           H8/500 Machine Directives
  359. * H8/500 Opcodes::              Opcodes
  360. File: as.info,  Node: H8/500 Options,  Next: H8/500 Syntax,  Up: H8/500-Dependent
  361. Options
  362. -------
  363.    `as' has no additional command-line options for the Hitachi H8/500
  364. family.
  365. File: as.info,  Node: H8/500 Syntax,  Next: H8/500 Floating Point,  Prev: H8/500 Options,  Up: H8/500-Dependent
  366. Syntax
  367. ------
  368. * Menu:
  369. * H8/500-Chars::                Special Characters
  370. * H8/500-Regs::                 Register Names
  371. * H8/500-Addressing::           Addressing Modes
  372. File: as.info,  Node: H8/500-Chars,  Next: H8/500-Regs,  Up: H8/500 Syntax
  373. Special Characters
  374. ..................
  375.    `!' is the line comment character.
  376.    `;' can be used instead of a newline to separate statements.
  377.    Since `$' has no special meaning, you may use it in symbol names.
  378. File: as.info,  Node: H8/500-Regs,  Next: H8/500-Addressing,  Prev: H8/500-Chars,  Up: H8/500 Syntax
  379. Register Names
  380. ..............
  381.    You can use the predefined symbols `r0', `r1', `r2', `r3', `r4',
  382. `r5', `r6', and `r7' to refer to the H8/500 registers.
  383.    The H8/500 also has these control registers:
  384.      code pointer
  385.      data pointer
  386.      base pointer
  387.      stack top pointer
  388.      extra pointer
  389.      status register
  390. `ccr'
  391.      condition code register
  392.    All registers are 16 bits long.  To represent 32 bit numbers, use two
  393. adjacent registers; for distant memory addresses, use one of the segment
  394. pointers (`cp' for the program counter; `dp' for `r0'-`r3'; `ep' for
  395. `r4' and `r5'; and `tp' for `r6' and `r7'.
  396. File: as.info,  Node: H8/500-Addressing,  Prev: H8/500-Regs,  Up: H8/500 Syntax
  397. Addressing Modes
  398. ................
  399.    as understands the following addressing modes for the H8/500:
  400.      Register direct
  401. `@RN'
  402.      Register indirect
  403. `@(d:8, RN)'
  404.      Register indirect with 8 bit signed displacement
  405. `@(d:16, RN)'
  406.      Register indirect with 16 bit signed displacement
  407. `@-RN'
  408.      Register indirect with pre-decrement
  409. `@RN+'
  410.      Register indirect with post-increment
  411. `@AA:8'
  412.      8 bit absolute address
  413. `@AA:16'
  414.      16 bit absolute address
  415. `#XX:8'
  416.      8 bit immediate
  417. `#XX:16'
  418.      16 bit immediate
  419. File: as.info,  Node: H8/500 Floating Point,  Next: H8/500 Directives,  Prev: H8/500 Syntax,  Up: H8/500-Dependent
  420. Floating Point
  421. --------------
  422.    The H8/500 family uses IEEE floating-point numbers.
  423. File: as.info,  Node: H8/500 Directives,  Next: H8/500 Opcodes,  Prev: H8/500 Floating Point,  Up: H8/500-Dependent
  424. H8/500 Machine Directives
  425. -------------------------
  426.    `as' has no machine-dependent directives for the H8/500.  However,
  427. on this platform the `.int' and `.word' directives generate 16-bit
  428. numbers.
  429. File: as.info,  Node: H8/500 Opcodes,  Prev: H8/500 Directives,  Up: H8/500-Dependent
  430. Opcodes
  431. -------
  432.    For detailed information on the H8/500 machine instruction set, see
  433. `H8/500 Series Programming Manual' (Hitachi M21T001).
  434.    `as' implements all the standard H8/500 opcodes.  No additional
  435. pseudo-instructions are needed on this family.
  436.    The following table summarizes H8/500 opcodes and their operands:
  437.      Legend:
  438.      abs8      8-bit absolute address
  439.      abs16     16-bit absolute address
  440.      abs24     24-bit absolute address
  441.      crb       `ccr', `br', `ep', `dp', `tp', `dp'
  442.      disp8     8-bit displacement
  443.      ea        `rn', `@rn', `@(d:8, rn)', `@(d:16, rn)',
  444.                `@-rn', `@rn+', `@aa:8', `@aa:16',
  445.                `#xx:8', `#xx:16'
  446.      ea_mem    `@rn', `@(d:8, rn)', `@(d:16, rn)',
  447.                `@-rn', `@rn+', `@aa:8', `@aa:16'
  448.      ea_noimm  `rn', `@rn', `@(d:8, rn)', `@(d:16, rn)',
  449.                `@-rn', `@rn+', `@aa:8', `@aa:16'
  450.      fp        r6
  451.      imm4      4-bit immediate data
  452.      imm8      8-bit immediate data
  453.      imm16     16-bit immediate data
  454.      pcrel8    8-bit offset from program counter
  455.      pcrel16   16-bit offset from program counter
  456.      qim       `-2', `-1', `1', `2'
  457.      rd        any register
  458.      rs        a register distinct from rd
  459.      rlist     comma-separated list of registers in parentheses;
  460.                register ranges `rd-rs' are allowed
  461.      sp        stack pointer (`r7')
  462.      sr        status register
  463.      sz        size; `.b' or `.w'.  If omitted, default `.w'
  464.      
  465.      ldc[.b] ea,crb                 bcc[.w] pcrel16
  466.      ldc[.w] ea,sr                  bcc[.b] pcrel8
  467.      add[:q] sz qim,ea_noimm        bhs[.w] pcrel16
  468.      add[:g] sz ea,rd               bhs[.b] pcrel8
  469.      adds sz ea,rd                  bcs[.w] pcrel16
  470.      addx sz ea,rd                  bcs[.b] pcrel8
  471.      and sz ea,rd                   blo[.w] pcrel16
  472.      andc[.b] imm8,crb              blo[.b] pcrel8
  473.      andc[.w] imm16,sr              bne[.w] pcrel16
  474.      bpt                            bne[.b] pcrel8
  475.      bra[.w] pcrel16                beq[.w] pcrel16
  476.      bra[.b] pcrel8                 beq[.b] pcrel8
  477.      bt[.w] pcrel16                 bvc[.w] pcrel16
  478.      bt[.b] pcrel8                  bvc[.b] pcrel8
  479.      brn[.w] pcrel16                bvs[.w] pcrel16
  480.      brn[.b] pcrel8                 bvs[.b] pcrel8
  481.      bf[.w] pcrel16                 bpl[.w] pcrel16
  482.      bf[.b] pcrel8                  bpl[.b] pcrel8
  483.      bhi[.w] pcrel16                bmi[.w] pcrel16
  484.      bhi[.b] pcrel8                 bmi[.b] pcrel8
  485.      bls[.w] pcrel16                bge[.w] pcrel16
  486.      bls[.b] pcrel8                 bge[.b] pcrel8
  487.      
  488.      blt[.w] pcrel16                mov[:g][.b] imm8,ea_mem
  489.      blt[.b] pcrel8                 mov[:g][.w] imm16,ea_mem
  490.      bgt[.w] pcrel16                movfpe[.b] ea,rd
  491.      bgt[.b] pcrel8                 movtpe[.b] rs,ea_noimm
  492.      ble[.w] pcrel16                mulxu sz ea,rd
  493.      ble[.b] pcrel8                 neg sz ea
  494.      bclr sz imm4,ea_noimm          nop
  495.      bclr sz rs,ea_noimm            not sz ea
  496.      bnot sz imm4,ea_noimm          or sz ea,rd
  497.      bnot sz rs,ea_noimm            orc[.b] imm8,crb
  498.      bset sz imm4,ea_noimm          orc[.w] imm16,sr
  499.      bset sz rs,ea_noimm            pjmp abs24
  500.      bsr[.b] pcrel8                 pjmp @rd
  501.      bsr[.w] pcrel16                pjsr abs24
  502.      btst sz imm4,ea_noimm          pjsr @rd
  503.      btst sz rs,ea_noimm            prtd imm8
  504.      clr sz ea                      prtd imm16
  505.      cmp[:e][.b] imm8,rd            prts
  506.      cmp[:i][.w] imm16,rd           rotl sz ea
  507.      cmp[:g].b imm8,ea_noimm        rotr sz ea
  508.      cmp[:g][.w] imm16,ea_noimm     rotxl sz ea
  509.      Cmp[:g] sz ea,rd               rotxr sz ea
  510.      dadd rs,rd                     rtd imm8
  511.      divxu sz ea,rd                 rtd imm16
  512.      dsub rs,rd                     rts
  513.      exts[.b] rd                    scb/f rs,pcrel8
  514.      extu[.b] rd                    scb/ne rs,pcrel8
  515.      jmp @rd                        scb/eq rs,pcrel8
  516.      jmp @(imm8,rd)                 shal sz ea
  517.      jmp @(imm16,rd)                shar sz ea
  518.      jmp abs16                      shll sz ea
  519.      jsr @rd                        shlr sz ea
  520.      jsr @(imm8,rd)                 sleep
  521.      jsr @(imm16,rd)                stc[.b] crb,ea_noimm
  522.      jsr abs16                      stc[.w] sr,ea_noimm
  523.      ldm @sp+,(rlist)               stm (rlist),@-sp
  524.      link fp,imm8                   sub sz ea,rd
  525.      link fp,imm16                  subs sz ea,rd
  526.      mov[:e][.b] imm8,rd            subx sz ea,rd
  527.      mov[:i][.w] imm16,rd           swap[.b] rd
  528.      mov[:l][.w] abs8,rd            tas[.b] ea
  529.      mov[:l].b abs8,rd              trapa imm4
  530.      mov[:s][.w] rs,abs8            trap/vs
  531.      mov[:s].b rs,abs8              tst sz ea
  532.      mov[:f][.w] @(disp8,fp),rd     unlk fp
  533.      mov[:f][.w] rs,@(disp8,fp)     xch[.w] rs,rd
  534.      mov[:f].b @(disp8,fp),rd       xor sz ea,rd
  535.      mov[:f].b rs,@(disp8,fp)       xorc.b imm8,crb
  536.      mov[:g] sz rs,ea_mem           xorc.w imm16,sr
  537.      mov[:g] sz ea,rd
  538. File: as.info,  Node: SH-Dependent,  Next: i960-Dependent,  Prev: H8/500-Dependent,  Up: Machine Dependencies
  539. Hitachi SH Dependent Features
  540. =============================
  541. * Menu:
  542. * SH Options::              Options
  543. * SH Syntax::               Syntax
  544. * SH Floating Point::       Floating Point
  545. * SH Directives::           SH Machine Directives
  546. * SH Opcodes::              Opcodes
  547. File: as.info,  Node: SH Options,  Next: SH Syntax,  Up: SH-Dependent
  548. Options
  549. -------
  550.    `as' has no additional command-line options for the Hitachi SH
  551. family.
  552. File: as.info,  Node: SH Syntax,  Next: SH Floating Point,  Prev: SH Options,  Up: SH-Dependent
  553. Syntax
  554. ------
  555. * Menu:
  556. * SH-Chars::                Special Characters
  557. * SH-Regs::                 Register Names
  558. * SH-Addressing::           Addressing Modes
  559. File: as.info,  Node: SH-Chars,  Next: SH-Regs,  Up: SH Syntax
  560. Special Characters
  561. ..................
  562.    `!' is the line comment character.
  563.    You can use `;' instead of a newline to separate statements.
  564.    Since `$' has no special meaning, you may use it in symbol names.
  565. File: as.info,  Node: SH-Regs,  Next: SH-Addressing,  Prev: SH-Chars,  Up: SH Syntax
  566. Register Names
  567. ..............
  568.    You can use the predefined symbols `r0', `r1', `r2', `r3', `r4',
  569. `r5', `r6', `r7', `r8', `r9', `r10', `r11', `r12', `r13', `r14', and
  570. `r15' to refer to the SH registers.
  571.    The SH also has these control registers:
  572.      procedure register (holds return address)
  573.      program counter
  574. `mach'
  575. `macl'
  576.      high and low multiply accumulator registers
  577.      status register
  578. `gbr'
  579.      global base register
  580. `vbr'
  581.      vector base register (for interrupt vectors)
  582. File: as.info,  Node: SH-Addressing,  Prev: SH-Regs,  Up: SH Syntax
  583. Addressing Modes
  584. ................
  585.    `as' understands the following addressing modes for the SH.  `RN' in
  586. the following refers to any of the numbered registers, but *not* the
  587. control registers.
  588.      Register direct
  589. `@RN'
  590.      Register indirect
  591. `@-RN'
  592.      Register indirect with pre-decrement
  593. `@RN+'
  594.      Register indirect with post-increment
  595. `@(DISP, RN)'
  596.      Register indirect with displacement
  597. `@(R0, RN)'
  598.      Register indexed
  599. `@(DISP, GBR)'
  600.      `GBR' offset
  601. `@(R0, GBR)'
  602.      GBR indexed
  603. `ADDR'
  604. `@(DISP, PC)'
  605.      PC relative address (for branch or for addressing memory).  The
  606.      `as' implementation allows you to use the simpler form ADDR
  607.      anywhere a PC relative address is called for; the alternate form
  608.      is supported for compatibility with other assemblers.
  609. `#IMM'
  610.      Immediate data
  611. File: as.info,  Node: SH Floating Point,  Next: SH Directives,  Prev: SH Syntax,  Up: SH-Dependent
  612. Floating Point
  613. --------------
  614.    The SH family uses IEEE floating-point numbers.
  615. File: as.info,  Node: SH Directives,  Next: SH Opcodes,  Prev: SH Floating Point,  Up: SH-Dependent
  616. SH Machine Directives
  617. ---------------------
  618.    `as' has no machine-dependent directives for the SH.
  619. File: as.info,  Node: SH Opcodes,  Prev: SH Directives,  Up: SH-Dependent
  620. Opcodes
  621. -------
  622.    For detailed information on the SH machine instruction set, see
  623. `SH-Microcomputer User's Manual' (Hitachi Micro Systems, Inc.).
  624.    `as' implements all the standard SH opcodes.  No additional
  625. pseudo-instructions are needed on this family.  Note, however, that
  626. because `as' supports a simpler form of PC-relative addressing, you may
  627. simply write (for example)
  628.      mov.l  bar,r0
  629. where other assemblers might require an explicit displacement to `bar'
  630. from the program counter:
  631.      mov.l  @(DISP, PC)
  632.    Here is a summary of SH opcodes:
  633.      Legend:
  634.      Rn        a numbered register
  635.      Rm        another numbered register
  636.      #imm      immediate data
  637.      disp      displacement
  638.      disp8     8-bit displacement
  639.      disp12    12-bit displacement
  640.      
  641.      add #imm,Rn                    lds.l @Rn+,PR
  642.      add Rm,Rn                      mac.w @Rm+,@Rn+
  643.      addc Rm,Rn                     mov #imm,Rn
  644.      addv Rm,Rn                     mov Rm,Rn
  645.      and #imm,R0                    mov.b Rm,@(R0,Rn)
  646.      and Rm,Rn                      mov.b Rm,@-Rn
  647.      and.b #imm,@(R0,GBR)           mov.b Rm,@Rn
  648.      bf disp8                       mov.b @(disp,Rm),R0
  649.      bra disp12                     mov.b @(disp,GBR),R0
  650.      bsr disp12                     mov.b @(R0,Rm),Rn
  651.      bt disp8                       mov.b @Rm+,Rn
  652.      clrm                           mov.b @Rm,Rn
  653.      clrt                           mov.b R0,@(disp,Rm)
  654.      cmp/eq #imm,R0                 mov.b R0,@(disp,GBR)
  655.      cmp/eq Rm,Rn                   mov.l Rm,@(disp,Rn)
  656.      cmp/ge Rm,Rn                   mov.l Rm,@(R0,Rn)
  657.      cmp/gt Rm,Rn                   mov.l Rm,@-Rn
  658.      cmp/hi Rm,Rn                   mov.l Rm,@Rn
  659.      cmp/hs Rm,Rn                   mov.l @(disp,Rn),Rm
  660.      cmp/pl Rn                      mov.l @(disp,GBR),R0
  661.      cmp/pz Rn                      mov.l @(disp,PC),Rn
  662.      cmp/str Rm,Rn                  mov.l @(R0,Rm),Rn
  663.      div0s Rm,Rn                    mov.l @Rm+,Rn
  664.      div0u                          mov.l @Rm,Rn
  665.      div1 Rm,Rn                     mov.l R0,@(disp,GBR)
  666.      exts.b Rm,Rn                   mov.w Rm,@(R0,Rn)
  667.      exts.w Rm,Rn                   mov.w Rm,@-Rn
  668.      extu.b Rm,Rn                   mov.w Rm,@Rn
  669.      extu.w Rm,Rn                   mov.w @(disp,Rm),R0
  670.      jmp @Rn                        mov.w @(disp,GBR),R0
  671.      jsr @Rn                        mov.w @(disp,PC),Rn
  672.      ldc Rn,GBR                     mov.w @(R0,Rm),Rn
  673.      ldc Rn,SR                      mov.w @Rm+,Rn
  674.      ldc Rn,VBR                     mov.w @Rm,Rn
  675.      ldc.l @Rn+,GBR                 mov.w R0,@(disp,Rm)
  676.      ldc.l @Rn+,SR                  mov.w R0,@(disp,GBR)
  677.      ldc.l @Rn+,VBR                 mova @(disp,PC),R0
  678.      lds Rn,MACH                    movt Rn
  679.      lds Rn,MACL                    muls Rm,Rn
  680.      lds Rn,PR                      mulu Rm,Rn
  681.      lds.l @Rn+,MACH                neg Rm,Rn
  682.      lds.l @Rn+,MACL                negc Rm,Rn
  683.      
  684.      nop                            stc VBR,Rn
  685.      not Rm,Rn                      stc.l GBR,@-Rn
  686.      or #imm,R0                     stc.l SR,@-Rn
  687.      or Rm,Rn                       stc.l VBR,@-Rn
  688.      or.b #imm,@(R0,GBR)            sts MACH,Rn
  689.      rotcl Rn                       sts MACL,Rn
  690.      rotcr Rn                       sts PR,Rn
  691.      rotl Rn                        sts.l MACH,@-Rn
  692.      rotr Rn                        sts.l MACL,@-Rn
  693.      rte                            sts.l PR,@-Rn
  694.      rts                            sub Rm,Rn
  695.      sett                           subc Rm,Rn
  696.      shal Rn                        subv Rm,Rn
  697.      shar Rn                        swap.b Rm,Rn
  698.      shll Rn                        swap.w Rm,Rn
  699.      shll16 Rn                      tas.b @Rn
  700.      shll2 Rn                       trapa #imm
  701.      shll8 Rn                       tst #imm,R0
  702.      shlr Rn                        tst Rm,Rn
  703.      shlr16 Rn                      tst.b #imm,@(R0,GBR)
  704.      shlr2 Rn                       xor #imm,R0
  705.      shlr8 Rn                       xor Rm,Rn
  706.      sleep                          xor.b #imm,@(R0,GBR)
  707.      stc GBR,Rn                     xtrct Rm,Rn
  708.      stc SR,Rn
  709. File: as.info,  Node: i960-Dependent,  Next: M68K-Dependent,  Prev: SH-Dependent,  Up: Machine Dependencies
  710. Intel 80960 Dependent Features
  711. ==============================
  712. * Menu:
  713. * Options-i960::                i960 Command-line Options
  714. * Floating Point-i960::         Floating Point
  715. * Directives-i960::             i960 Machine Directives
  716. * Opcodes for i960::            i960 Opcodes
  717. File: as.info,  Node: Options-i960,  Next: Floating Point-i960,  Up: i960-Dependent
  718. i960 Command-line Options
  719. -------------------------
  720. `-ACA | -ACA_A | -ACB | -ACC | -AKA | -AKB | -AKC | -AMC'
  721.      Select the 80960 architecture.  Instructions or features not
  722.      supported by the selected architecture cause fatal errors.
  723.      `-ACA' is equivalent to `-ACA_A'; `-AKC' is equivalent to `-AMC'.
  724.      Synonyms are provided for compatibility with other tools.
  725.      If none of these options is specified, `as' will generate code for
  726.      any instruction or feature that is supported by *some* version of
  727.      the 960 (even if this means mixing architectures!).  In principle,
  728.      `as' will attempt to deduce the minimal sufficient processor type
  729.      if none is specified; depending on the object code format, the
  730.      processor type may be recorded in the object file.  If it is
  731.      critical that the `as' output match a specific architecture,
  732.      specify that architecture explicitly.
  733.      Add code to collect information about conditional branches taken,
  734.      for later optimization using branch prediction bits.  (The
  735.      conditional branch instructions have branch prediction bits in the
  736.      CA, CB, and CC architectures.)  If BR represents a conditional
  737.      branch instruction, the following represents the code generated by
  738.      the assembler when `-b' is specified:
  739.                   call    INCREMENT ROUTINE
  740.                   .word   0       # pre-counter
  741.           Label:  BR
  742.                   call    INCREMENT ROUTINE
  743.                   .word   0       # post-counter
  744.      The counter following a branch records the number of times that
  745.      branch was *not* taken; the differenc between the two counters is
  746.      the number of times the branch *was* taken.
  747.      A table of every such `Label' is also generated, so that the
  748.      external postprocessor `gbr960' (supplied by Intel) can locate all
  749.      the counters.  This table is always labelled `__BRANCH_TABLE__';
  750.      this is a local symbol to permit collecting statistics for many
  751.      separate object files.  The table is word aligned, and begins with
  752.      a two-word header.  The first word, initialized to 0, is used in
  753.      maintaining linked lists of branch tables.  The second word is a
  754.      count of the number of entries in the table, which follow
  755.      immediately: each is a word, pointing to one of the labels
  756.      illustrated above.
  757.            +------------+------------+------------+ ... +------------+
  758.            |            |            |            |     |            |
  759.            |  *NEXT     |  COUNT: N  | *BRLAB 1   |     | *BRLAB N   |
  760.            |            |            |            |     |            |
  761.            +------------+------------+------------+ ... +------------+
  762.           
  763.                          __BRANCH_TABLE__ layout
  764.      The first word of the header is used to locate multiple branch
  765.      tables, since each object file may contain one. Normally the links
  766.      are maintained with a call to an initialization routine, placed at
  767.      the beginning of each function in the file.  The GNU C compiler
  768.      will generate these calls automatically when you give it a `-b'
  769.      option.  For further details, see the documentation of `gbr960'.
  770. `-norelax'
  771.      Normally, Compare-and-Branch instructions with targets that require
  772.      displacements greater than 13 bits (or that have external targets)
  773.      are replaced with the corresponding compare (or `chkbit') and
  774.      branch instructions.  You can use the `-norelax' option to specify
  775.      that `as' should generate errors instead, if the target
  776.      displacement is larger than 13 bits.
  777.      This option does not affect the Compare-and-Jump instructions; the
  778.      code emitted for them is *always* adjusted when necessary
  779.      (depending on displacement size), regardless of whether you use
  780.      `-norelax'.
  781. File: as.info,  Node: Floating Point-i960,  Next: Directives-i960,  Prev: Options-i960,  Up: i960-Dependent
  782. Floating Point
  783. --------------
  784.    `as' generates IEEE floating-point numbers for the directives
  785. `.float', `.double', `.extended', and `.single'.
  786. File: as.info,  Node: Directives-i960,  Next: Opcodes for i960,  Prev: Floating Point-i960,  Up: i960-Dependent
  787. i960 Machine Directives
  788. -----------------------
  789. `.bss SYMBOL, LENGTH, ALIGN'
  790.      Reserve LENGTH bytes in the bss section for a local SYMBOL,
  791.      aligned to the power of two specified by ALIGN.  LENGTH and ALIGN
  792.      must be positive absolute expressions.  This directive differs
  793.      from `.lcomm' only in that it permits you to specify an alignment.
  794.      *Note `.lcomm': Lcomm.
  795. `.extended FLONUMS'
  796.      `.extended' expects zero or more flonums, separated by commas; for
  797.      each flonum, `.extended' emits an IEEE extended-format (80-bit)
  798.      floating-point number.
  799. `.leafproc CALL-LAB, BAL-LAB'
  800.      You can use the `.leafproc' directive in conjunction with the
  801.      optimized `callj' instruction to enable faster calls of leaf
  802.      procedures.  If a procedure is known to call no other procedures,
  803.      you may define an entry point that skips procedure prolog code
  804.      (and that does not depend on system-supplied saved context), and
  805.      declare it as the BAL-LAB using `.leafproc'.  If the procedure
  806.      also has an entry point that goes through the normal prolog, you
  807.      can specify that entry point as CALL-LAB.
  808.      A `.leafproc' declaration is meant for use in conjunction with the
  809.      optimized call instruction `callj'; the directive records the data
  810.      needed later to choose between converting the `callj' into a `bal'
  811.      or a `call'.
  812.      CALL-LAB is optional; if only one argument is present, or if the
  813.      two arguments are identical, the single argument is assumed to be
  814.      the `bal' entry point.
  815. `.sysproc NAME, INDEX'
  816.      The `.sysproc' directive defines a name for a system procedure.
  817.      After you define it using `.sysproc', you can use NAME to refer to
  818.      the system procedure identified by INDEX when calling procedures
  819.      with the optimized call instruction `callj'.
  820.      Both arguments are required; INDEX must be between 0 and 31
  821.      (inclusive).
  822. File: as.info,  Node: Opcodes for i960,  Prev: Directives-i960,  Up: i960-Dependent
  823. i960 Opcodes
  824. ------------
  825.    All Intel 960 machine instructions are supported; *note i960
  826. Command-line Options: Options-i960. for a discussion of selecting the
  827. instruction subset for a particular 960 architecture.
  828.    Some opcodes are processed beyond simply emitting a single
  829. corresponding instruction: `callj', and Compare-and-Branch or
  830. Compare-and-Jump instructions with target displacements larger than 13
  831. bits.
  832. * Menu:
  833. * callj-i960::                  `callj'
  834. * Compare-and-branch-i960::     Compare-and-Branch
  835. File: as.info,  Node: callj-i960,  Next: Compare-and-branch-i960,  Up: Opcodes for i960
  836. `callj'
  837. .......
  838.    You can write `callj' to have the assembler or the linker determine
  839. the most appropriate form of subroutine call: `call', `bal', or
  840. `calls'.  If the assembly source contains enough information--a
  841. `.leafproc' or `.sysproc' directive defining the operand--then `as'
  842. will translate the `callj'; if not, it will simply emit the `callj',
  843. leaving it for the linker to resolve.
  844. File: as.info,  Node: Compare-and-branch-i960,  Prev: callj-i960,  Up: Opcodes for i960
  845. Compare-and-Branch
  846. ..................
  847.    The 960 architectures provide combined Compare-and-Branch
  848. instructions that permit you to store the branch target in the lower 13
  849. bits of the instruction word itself.  However, if you specify a branch
  850. target far enough away that its address won't fit in 13 bits, the
  851. assembler can either issue an error, or convert your Compare-and-Branch
  852. instruction into separate instructions to do the compare and the branch.
  853.    Whether `as' gives an error or expands the instruction depends on
  854. two choices you can make: whether you use the `-norelax' option, and
  855. whether you use a "Compare and Branch" instruction or a "Compare and
  856. Jump" instruction.  The "Jump" instructions are *always* expanded if
  857. necessary; the "Branch" instructions are expanded when necessary
  858. *unless* you specify `-norelax'--in which case `as' gives an error
  859. instead.
  860.    These are the Compare-and-Branch instructions, their "Jump" variants,
  861. and the instruction pairs they may expand into:
  862.              Compare and
  863.           Branch      Jump       Expanded to
  864.           ------    ------       ------------
  865.              bbc                 chkbit; bno
  866.              bbs                 chkbit; bo
  867.           cmpibe    cmpije       cmpi; be
  868.           cmpibg    cmpijg       cmpi; bg
  869.          cmpibge   cmpijge       cmpi; bge
  870.           cmpibl    cmpijl       cmpi; bl
  871.          cmpible   cmpijle       cmpi; ble
  872.          cmpibno   cmpijno       cmpi; bno
  873.          cmpibne   cmpijne       cmpi; bne
  874.           cmpibo    cmpijo       cmpi; bo
  875.           cmpobe    cmpoje       cmpo; be
  876.           cmpobg    cmpojg       cmpo; bg
  877.          cmpobge   cmpojge       cmpo; bge
  878.           cmpobl    cmpojl       cmpo; bl
  879.          cmpoble   cmpojle       cmpo; ble
  880.          cmpobne   cmpojne       cmpo; bne
  881. File: as.info,  Node: M68K-Dependent,  Next: Sparc-Dependent,  Prev: i960-Dependent,  Up: Machine Dependencies
  882. M680x0 Dependent Features
  883. =========================
  884. * Menu:
  885. * M68K-Opts::                   M680x0 Options
  886. * M68K-Syntax::                 Syntax
  887. * M68K-Moto-Syntax::            Motorola Syntax
  888. * M68K-Float::                  Floating Point
  889. * M68K-Directives::             680x0 Machine Directives
  890. * M68K-opcodes::                Opcodes
  891. File: as.info,  Node: M68K-Opts,  Next: M68K-Syntax,  Up: M68K-Dependent
  892. M680x0 Options
  893. --------------
  894.    The Motorola 680x0 version of `as' has two machine dependent options.
  895. One shortens undefined references from 32 to 16 bits, while the other
  896. is used to tell `as' what kind of machine it is assembling for.
  897.    You can use the `-l' option to shorten the size of references to
  898. undefined symbols.  If the `-l' option is not given, references to
  899. undefined symbols will be a full long (32 bits) wide.  (Since `as'
  900. cannot know where these symbols will end up, `as' can only allocate
  901. space for the linker to fill in later.  Since `as' doesn't know how far
  902. away these symbols will be, it allocates as much space as it can.) If
  903. this option is given, the references will only be one word wide (16
  904. bits).  This may be useful if you want the object file to be as small as
  905. possible, and you know that the relevant symbols will be less than 17
  906. bits away.
  907.    The 680x0 version of `as' is most frequently used to assemble
  908. programs for the Motorola MC68020 microprocessor.  Occasionally it is
  909. used to assemble programs for the mostly similar, but slightly different
  910. MC68000 or MC68010 microprocessors.  You can give `as' the options
  911. `-m68000', `-mc68000', `-m68010', `-mc68010', `-m68020', and `-mc68020'
  912. to tell it what processor is the target.
  913. File: as.info,  Node: M68K-Syntax,  Next: M68K-Moto-Syntax,  Prev: M68K-Opts,  Up: M68K-Dependent
  914. Syntax
  915. ------
  916.    This syntax for the Motorola 680x0 was developed at MIT.
  917.    The 680x0 version of `as' uses syntax similar to the Sun assembler.
  918. Intervening periods are now ignored; for example, `movl' is equivalent
  919. to `move.l'.
  920.    In the following table "apc" stands for any of the address registers
  921. (`a0' through `a7'), nothing, (`'), the Program Counter (`pc'), or the
  922. zero-address relative to the program counter (`zpc').
  923.    The following addressing modes are understood:
  924. "Immediate"
  925.      `#DIGITS'
  926. "Data Register"
  927.      `d0' through `d7'
  928. "Address Register"
  929.      `a0' through `a7'
  930. "Address Register Indirect"
  931.      `a0@' through `a7@'
  932.      `a7' is also known as `sp', i.e. the Stack Pointer.  `a6' is also
  933.      known as `fp', the Frame Pointer.
  934. "Address Register Postincrement"
  935.      `a0@+' through `a7@+'
  936. "Address Register Predecrement"
  937.      `a0@-' through `a7@-'
  938. "Indirect Plus Offset"
  939.      `APC@(DIGITS)'
  940. "Index"
  941.      `APC@(DIGITS,REGISTER:SIZE:SCALE)'
  942.      or `APC@(REGISTER:SIZE:SCALE)'
  943. "Postindex"
  944.      `APC@(DIGITS)@(DIGITS,REGISTER:SIZE:SCALE)'
  945.      or `APC@(DIGITS)@(REGISTER:SIZE:SCALE)'
  946. "Preindex"
  947.      `APC@(DIGITS,REGISTER:SIZE:SCALE)@(DIGITS)'
  948.      or `APC@(REGISTER:SIZE:SCALE)@(DIGITS)'
  949. "Memory Indirect"
  950.      `APC@(DIGITS)@(DIGITS)'
  951. "Absolute"
  952.      `SYMBOL', or `DIGITS'
  953.    For some configurations, especially those where the compiler normally
  954. does not prepend an underscore to the names of user variables, the
  955. assembler requires a `%' before any use of a register name.  This is
  956. intended to let the assembler distinguish between user variables and
  957. registers named `a0' through `a7', et cetera.  The `%' is always
  958. accepted, but is only required for some configurations, notably
  959. `m68k-coff'.
  960. File: as.info,  Node: M68K-Moto-Syntax,  Next: M68K-Float,  Prev: M68K-Syntax,  Up: M68K-Dependent
  961. Motorola Syntax
  962. ---------------
  963.    The standard Motorola syntax for this chip differs from the syntax
  964. already discussed (*note Syntax: M68K-Syntax.).  `as' can accept both
  965. kinds of syntax, even within a single instruction.  The syntaxes are
  966. fully compatible, because the Motorola syntax never uses the `@'
  967. character and the MIT syntax always does, except in cases where the
  968. syntaxes are identical.
  969.    In particular, you may write or generate M68K assembler with the
  970. following conventions:
  971.    (In the following table "apc" stands for any of the address
  972. registers (`a0' through `a7'), nothing, (`'), the Program Counter
  973. (`pc'), or the zero-address relative to the program counter (`zpc').)
  974.    The following additional addressing modes are understood:
  975. "Address Register Indirect"
  976.      `a0' through `a7'
  977.      `a7' is also known as `sp', i.e. the Stack Pointer.  `a6' is also
  978.      known as `fp', the Frame Pointer.
  979. "Address Register Postincrement"
  980.      `(a0)+' through `(a7)+'
  981. "Address Register Predecrement"
  982.      `-(a0)' through `-(a7)'
  983. "Indirect Plus Offset"
  984.      `DIGITS(APC)'
  985. "Index"
  986.      `DIGITS(APC,(REGISTER.SIZE*SCALE)'
  987.      or `(APC,REGISTER.SIZE*SCALE)'
  988.      In either case, SIZE and SCALE are optional (SCALE defaults to
  989.      `1', SIZE defaults to `l').   SCALE can be `1', `2', `4', or `8'.
  990.      SIZE can be `w' or `l'.  SCALE is only supported on the 68020 and
  991.      greater.
  992. File: as.info,  Node: M68K-Float,  Next: M68K-Directives,  Prev: M68K-Moto-Syntax,  Up: M68K-Dependent
  993. Floating Point
  994. --------------
  995.    The floating point code is not too well tested, and may have subtle
  996. bugs in it.
  997.    Packed decimal (P) format floating literals are not supported.  Feel
  998. free to add the code!
  999.    The floating point formats generated by directives are these.
  1000. `.float'
  1001.      `Single' precision floating point constants.
  1002. `.double'
  1003.      `Double' precision floating point constants.
  1004.    There is no directive to produce regions of memory holding extended
  1005. precision numbers, however they can be used as immediate operands to
  1006. floating-point instructions.  Adding a directive to create extended
  1007. precision numbers would not be hard, but it has not yet seemed
  1008. necessary.
  1009. File: as.info,  Node: M68K-Directives,  Next: M68K-opcodes,  Prev: M68K-Float,  Up: M68K-Dependent
  1010. 680x0 Machine Directives
  1011. ------------------------
  1012.    In order to be compatible with the Sun assembler the 680x0 assembler
  1013. understands the following directives.
  1014. `.data1'
  1015.      This directive is identical to a `.data 1' directive.
  1016. `.data2'
  1017.      This directive is identical to a `.data 2' directive.
  1018. `.even'
  1019.      This directive is identical to a `.align 1' directive.
  1020. `.skip'
  1021.      This directive is identical to a `.space' directive.
  1022. File: as.info,  Node: M68K-opcodes,  Prev: M68K-Directives,  Up: M68K-Dependent
  1023. Opcodes
  1024. -------
  1025. * Menu:
  1026. * M68K-Branch::                 Branch Improvement
  1027. * M68K-Chars::                  Special Characters
  1028. File: as.info,  Node: M68K-Branch,  Next: M68K-Chars,  Up: M68K-opcodes
  1029. Branch Improvement
  1030. ..................
  1031.    Certain pseudo opcodes are permitted for branch instructions.  They
  1032. expand to the shortest branch instruction that will reach the target.
  1033. Generally these mnemonics are made by substituting `j' for `b' at the
  1034. start of a Motorola mnemonic.
  1035.    The following table summarizes the pseudo-operations.  A `*' flags
  1036. cases that are more fully described after the table:
  1037.                Displacement
  1038.                +-------------------------------------------------
  1039.                |                68020   68000/10
  1040.      Pseudo-Op |BYTE    WORD    LONG    LONG      non-PC relative
  1041.                +-------------------------------------------------
  1042.           jbsr |bsrs    bsr     bsrl    jsr       jsr
  1043.            jra |bras    bra     bral    jmp       jmp
  1044.      *     jXX |bXXs    bXX     bXXl    bNXs;jmpl bNXs;jmp
  1045.      *    dbXX |dbXX    dbXX        dbXX; bra; jmpl
  1046.      *    fjXX |fbXXw   fbXXw   fbXXl             fbNXw;jmp
  1047.      
  1048.      XX: condition
  1049.      NX: negative of condition XX
  1050.                     `*'--see full description below
  1051. `jbsr'
  1052. `jra'
  1053.      These are the simplest jump pseudo-operations; they always map to
  1054.      one particular machine instruction, depending on the displacement
  1055.      to the branch target.
  1056. `jXX'
  1057.      Here, `jXX' stands for an entire family of pseudo-operations,
  1058.      where XX is a conditional branch or condition-code test.  The full
  1059.      list of pseudo-ops in this family is:
  1060.            jhi   jls   jcc   jcs   jne   jeq   jvc
  1061.            jvs   jpl   jmi   jge   jlt   jgt   jle
  1062.      For the cases of non-PC relative displacements and long
  1063.      displacements on the 68000 or 68010, `as' will issue a longer code
  1064.      fragment in terms of NX, the opposite condition to XX.  For
  1065.      example, for the non-PC relative case:
  1066.               jXX foo
  1067.      gives
  1068.                bNXs oof
  1069.                jmp foo
  1070.            oof:
  1071. `dbXX'
  1072.      The full family of pseudo-operations covered here is
  1073.            dbhi   dbls   dbcc   dbcs   dbne   dbeq   dbvc
  1074.            dbvs   dbpl   dbmi   dbge   dblt   dbgt   dble
  1075.            dbf    dbra   dbt
  1076.      Other than for word and byte displacements, when the source reads
  1077.      `dbXX foo', `as' will emit
  1078.                dbXX oo1
  1079.                bra oo2
  1080.            oo1:jmpl foo
  1081.            oo2:
  1082. `fjXX'
  1083.      This family includes
  1084.            fjne   fjeq   fjge   fjlt   fjgt   fjle   fjf
  1085.            fjt    fjgl   fjgle  fjnge  fjngl  fjngle fjngt
  1086.            fjnle  fjnlt  fjoge  fjogl  fjogt  fjole  fjolt
  1087.            fjor   fjseq  fjsf   fjsne  fjst   fjueq  fjuge
  1088.            fjugt  fjule  fjult  fjun
  1089.      For branch targets that are not PC relative, `as' emits
  1090.                fbNX oof
  1091.                jmp foo
  1092.            oof:
  1093.      when it encounters `fjXX foo'.
  1094.